package dao;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;



import entites.Domaine;
import entites.GroupeParcours;
import entites.GroupeUe;
import entites.Lieu;
import entites.Mention;
import entites.Parcours;
import entites.Personne;
import entites.Semestre;
import entites.UniteEnseignement;

//@Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.NESTED)
public class Dao implements IDao {
	
	@PersistenceContext
	private EntityManager em;

//__________________________________________________DAO PERSONNE______________________________________________________________________
	
	public void deletePersonne(String code) 
	{		
		
		Personne personne = em.find(Personne.class, code);
		if (personne == null) {
			throw new DaoException(2);
		}
		em.remove(personne);
	}

	
	@SuppressWarnings("unchecked")
	
	public List<Personne> findAllPersonne() 
	{		
		return em.createQuery("select p from Personne p").getResultList();	
	}

	
	@SuppressWarnings("unchecked")
	
	public List<Personne> findAllPersonneLike(String modele) 	
	{		
		return em.createQuery("select p from Personne p where p.nom like :modele")
		.setParameter("modele", modele).getResultList();
	}

	
	
	public Personne findPersonne(String code) 
	{		
		return em.find(Personne.class, code);
	}
	

	
	public Personne savePersonne(Personne personne) 
	{		
		em.persist(personne);
		return personne;
	}

	
	public Personne updatePersonne(Personne personne) 
	{		
		return em.merge(personne);
	}
	

	/**
	 * les ue dont la personne est responsable
	 * @param personne
	 * @return
	 */

	@SuppressWarnings("unchecked")
	
	public List<UniteEnseignement> FindUeOfResponsable(Personne personne){
		Personne personne2=em.find(Personne.class, personne.getCode());
		if(personne2==null) throw new DaoException("cette personne n'existe pas ",2	);
		return em.createQuery("select p from UniteEnseignement p left join p.responsables3 pd where CODE_PERSONNE = :idP").
		setParameter("idP", personne2.getCode()).getResultList();

	}

	/**
	 * les domaine dont la personne est responsable
	 * @param personne
	 * @return
	 */
	@SuppressWarnings("unchecked")
	
	public List<Domaine> FindDomainesOfResponsable(Personne personne){
		Personne personne2=em.find(Personne.class, personne.getCode());
		if(personne2==null) throw new DaoException("cette personne n'existe pas ",2	);
		return em.createQuery("select p from Domaine p left join p.responsables pd where CODE_PERSONNE = :idP").
		setParameter("idP", personne.getCode()).getResultList();
	}
	/**
	 * cette methode prmet de trouver les mentions dont la personne est responsable
	 * @param personne
	 * @return
	 */
	@SuppressWarnings("unchecked")
	
	public List<Mention> FindMentionOfResponsable(Personne personne){
		Personne personne2=em.find(Personne.class, personne.getCode());
		
		if(personne2==null) throw new DaoException("cette personne n'existe pas ",2	);
		return em.createQuery("select p from Mention p left join p.responsables2 pd where CODE_PERSONNE = :idP").
		setParameter("idP", personne2.getCode()).getResultList();
	}

	/**
	 * cette methode permet de trouver les parcours dont la personne est responsable
	 * @param personne
	 * @return
	 */
	@SuppressWarnings("unchecked")
	
	public List<Parcours> FindParcoursOfResponsable(Personne personne){
		Personne personne2=em.find(Personne.class, personne.getCode());
		if(personne2==null) throw new DaoException("cette personne n'existe pas ",2	);
		return em.createQuery("select p from Parcours p left join p.responsables1 pd where CODE_PERSONNE = :idP").
		setParameter("idP", personne.getCode()).getResultList();
	}

	
	
	

//__________________________________________________DAO DOMAINE______________________________________________________________________
	


	
	public void deleteDomaine(Integer id) 
	{		
		Domaine domaine = em.find(Domaine.class, id);
		if (domaine == null) {
			throw new DaoException(2);
		}
		em.remove(domaine);
	}

	
	@SuppressWarnings("unchecked")
	
	public List<Domaine> findAllDomaine() 
	{		
		return em.createQuery("select d from Domaine d").getResultList();
	}
	

	@SuppressWarnings("unchecked")
	
	public List<Domaine> findAllDomaineLike(String modele) 
	{		
		return em.createQuery("select d from Domaine d where d.libelle like :modele")
		.setParameter("modele", modele).getResultList();
	}

	
	public Domaine findDomaine(Integer id) 
	{		
		System.out.println(em);
		return em.find(Domaine.class, id);
	}

	
	
	public Domaine saveDomaine(Domaine domaine) 
	{		
		em.persist(domaine);
		return domaine;
	}

	
	
	public Domaine updateDomaine(Domaine domaine) 
	{		
		return em.merge(domaine);
	}

	
	
	public void addMentionToDomaine(Mention mention, Domaine domaine) 
	{		
		Domaine dom = em.find(Domaine.class, domaine.getId());
		
		if(dom == null)
			throw new DaoException("Ce domaine n'existe pas encore",2);
				 
		dom.addMention(mention);
		mention.setDomaine(domaine);
		em.persist(mention);
	}

	
	
	
	
	public void addSemestreToDomaine(Semestre semestre, Domaine domaine) 
	{		
		Domaine dom = em.find(Domaine.class, domaine.getId());
		
		if(dom==null)
			throw new DaoException("Ce domaine n'existe pas encore",2);
				 
		dom.addSemestre(semestre);
		semestre.setDomaine(domaine);
		em.persist(semestre);	
	}
	
	
	
	public void addUeToDomaine(UniteEnseignement ue, Domaine domaine) 
	{		
		Domaine dom = em.find(Domaine.class, domaine.getId());
		
		if(dom==null)
			throw new DaoException("Ce domaine n'existe pas encore",2);
		
		ue.setDomaine(dom);
		//dom.addUniteEnseignement(ue);
		
		System.out.println("=================L'entity manager est la :   "+em);
		em.merge(ue);	
		System.out.println("====================================================DAOOOOOOOOOOOOOOOOOOOOOOOO  : le code de l'ue dans la dao"+ue.getCode()+" le domaine de l'ue "+ue.getDomaine().getLibelle()+"  la liste des ue dans la domaine "+dom.getUnitesEnseignement().toString());
	}
		

	@SuppressWarnings("unchecked")
	
	public List<Mention> findAllMentionIntoDomaine(Domaine domaine) 
	{		
		Domaine dom = em.find(Domaine.class, domaine.getId());
		
		if(dom==null)
			throw new DaoException("ce domaine n'existe pas encore", 2);
				
		
		return em.createQuery("select m from Mention m where m.ID_DOMAINE = : idDomaine").
		setParameter("idDomaine",domaine.getId()).getResultList();
		
	}

	@SuppressWarnings("unchecked")
	
	public List<Semestre> findAllSemestreIntoDomaine(Domaine domaine) 
	{		
		Domaine dom = em.find(Domaine.class, domaine.getId());
		
		if(dom==null)
			throw new DaoException("ce domaine n'existe pas encore", 2);
				
		
		return em.createQuery("select s from Semestre s where ID_DOMAINE = : idDomaine").
		setParameter("idDomaine",domaine.getId()).getResultList();
	}
	
	

	@SuppressWarnings("unchecked")
	
	public List<UniteEnseignement> findAllUeIntoDomaine(Domaine domaine) 
	{		
		Domaine dom = em.find(Domaine.class, domaine.getId());
		
		if(dom==null)
			throw new DaoException("ce domaine n'existe pas encore", 2);
				
		
		return em.createQuery("select ue from UniteEnseignement ue where ue.domaine = : idDomaine").
		setParameter("idDomaine", dom.getId()).getResultList();
	}
	
	
	/**
	 * ajouter un responsable a un parcours
	 * @param personne
	 * @param parcours
	 */
	
	
	public void addResponsableToDomaine(Personne personne, Domaine domaine) {
		
		Domaine dom = em.find(Domaine.class, domaine.getId());
		if(dom==null){
			throw new DaoException("Ce domaine n'existe pas encore",2);
		}

		Personne personne2 = em.find(Personne.class, personne.getCode());
		if(personne2==null) throw new DaoException("cette personne n'existe pas",2);

		dom.addResponsable(personne2);
		personne2.addDomaine(dom);


		em.merge(personne2);
		em.merge(dom);

	}
	
	
	
	
	
	/**
	 * 
	 * 
	 */

	@SuppressWarnings("unchecked")
		
	public List<Personne> findResponsableDomaine(Domaine domaine)
	{

		Domaine dom = em.find(Domaine.class, domaine.getId());
		if(dom==null){
			throw new DaoException("ce domaine n'existe pas encore", 2);
		}

		return em.createQuery("select p from Personne p left join p.domaines pr where ID_DOMAINE = :idD").
		setParameter("idD", dom.getId()).getResultList();
	}
	
	
	
//__________________________________________________DAO PARCOURS______________________________________________________________________

	
	
	public void deleteParcours(String code) {
		
		Parcours parcours = em.find(Parcours.class,code);
		if (parcours == null) {
			throw new DaoException(2);
		}
		em.remove(parcours);
	}

	
	@SuppressWarnings("unchecked")
	
	public List<Parcours> findAllParcours() {
		
		return em.createQuery("select p from Parcours p").getResultList();
	}

	
	@SuppressWarnings("unchecked")
	
	public List<Parcours> findAllParcoursLike(String modele) {
		
		return em.createQuery("select p from Parcours p where p.libelle like :modele")
		.setParameter("modele", modele).getResultList();
		}

	
	public Parcours findParcours(String code) 
	{		
		return em.find(Parcours.class, code);
		
	}

	
	public Parcours saveParcours(Parcours parcours) {
		
		em.persist(parcours);
		return parcours;
	}

	
	public Parcours updateParcours(Parcours parcours) {
		
		return em.merge(parcours);
	}
	
	/**
	 * obtenir la liste des semestres d'un parcours
	 * @param parcours
	 * @return List<Semestre>
	 */
	@SuppressWarnings("unchecked")
	
	public List<Semestre> findAllSemestreIntoParcours(Parcours parcours){
		
		Parcours parcours2= em.find(Parcours.class, parcours.getCode());
		if(parcours2==null){
			 throw new DaoException("ce parcours n'existe pas encore", 2);
		}
		
		//int i= parcours.getId();
		 return em.createQuery("select s from Semestre s where 	CODE_PARCOURS = :codeParcours").
		 setParameter("codeParcours",parcours2.getCode()).getResultList();
		
	}

	/**
	 * ajouter un semestre a un parcours
	 * @param semestre
	 * @param parcours
	 */
	
	public void addSemestreToParcours(Semestre semestre, Parcours parcours){
		Parcours parcours2=em.find(Parcours.class, parcours.getCode());
		if (parcours2==null){
			throw new DaoException("ce parcours n'existe pas ", 2);
			
		}
		Mention mention = findMentionOfParcours(parcours2);
		
		Domaine domaine = findDomaineOfMention(mention);
		
		semestre.setDomaine(domaine);
		parcours2.addSemestre(semestre);
		semestre.setParcours(parcours2);
		em.persist(semestre);
		
		
	}

	/**
	 * obtenir la mention du parcours
	 * @param parcours
	 * @return Mention
	 */
	
	public Mention findMentionOfParcours(Parcours parcours){
		
		Parcours parcours2=em.find(Parcours.class, parcours.getCode());
		if (parcours2==null){
			throw new DaoException("ce parcours n'existe pas ", 2);
			
		}
		
		Mention mention=em.find(Mention.class, parcours2.getMention().getAcronyme());
		if(mention==null) return null;
		
		return mention;
	}
	
	/**
	 * obtenir le groupde de parcours auquel appartient le parcours
	 * @param parcours
	 * @return GroupeParcours
	 */
	
	public GroupeParcours findGroupeParcoursOfParcours(Parcours parcours)
	{
		Parcours parcours2 = em.find(Parcours.class,parcours.getCode());

		if (parcours2 == null)
			throw new DaoException("ce parcours n'existe pas ", 2);		

		GroupeParcours gparcours = em.find(GroupeParcours.class,parcours.getGroupeParcours().getAcronyme());

		if(gparcours == null) return null;

		return gparcours;		
	}
	
	


	@SuppressWarnings("unchecked")
	
	public List<Personne> findAllResponsableIntoParcours(Parcours parcours) {
		
		Parcours parcours2 = em.find(Parcours.class, parcours.getCode());
		if(parcours2==null)  throw new DaoException("ce parcours n'existe pas", 2);

		return  em.createQuery("select p from Personne p left join p.listParcours pr where CODE_PARCOURS = :idD").
		setParameter("idD", parcours2.getCode()).getResultList();

	}

	/**
	 * ajouter un responsable a un parcours
	 * @param personne
	 * @param parcours
	 */
	
	public void addResponsableToParcours(Personne personne, Parcours parcours){
		Parcours parcours2=em.find(Parcours.class, parcours.getCode());
		if (parcours2==null){
			throw new DaoException("ce parcours n'existe pas ", 2);

		}

		Personne personne2 = em.find(Personne.class, personne.getCode());
		if(personne2==null) throw new DaoException("cette personne n'existe pas ", 2);

		parcours2.addResponsable(personne2);
		personne2.addParcours(parcours2);
		em.merge(personne2);
		em.merge(parcours2);
	}
	

/*	*//**
	 * obtenir la liste des responsables du parcours
	 * @param parcours
	 * @return List<Personne>
	 *//*
	@SuppressWarnings("unchecked")
	
	public List<Personne> findAllResponsableIntoParcours(Parcours parcours){
		Parcours parcours2= em.find(Parcours.class, parcours.getCodeParcours());
		if(parcours2==null){
			 throw new DaoException("ce parcours n'existe pas encore", 2);
		}
		 return em.createQuery("select p from RESPONSABLE_PARCOURS p where s.PARCOURS_ID = :idParcours").
		 setParameter("idParcours", parcours2.getId()).getResultList();
		
	}*/

	
//__________________________________________________DAO_MENTION______________________________________________________________________


	
	public void deleteMention(String acronyme) 
	{
		
		Mention mention=em.find(Mention.class, acronyme);
		if(mention==null){
			throw new DaoException(2);
		}
		
		em.remove(mention);
	}

	/**
	 * 
	 */
	@SuppressWarnings("unchecked")
	
	public List<Mention> findAllMention() {
		
		return em.createQuery("select m from Mention m ").getResultList();
	}

	
	@SuppressWarnings("unchecked")
	
	public List<Mention> findAllMentionLike(String modele) {
		
		return em.createQuery("select m from Mention m where m.libelle like :modele").
		setParameter("modele", modele).
		getResultList();
	}

	
	
	public Mention findMention(String acronyme) {
		
		return em.find(Mention.class, acronyme);
	}

	
	public Mention saveMention(Mention mention) {
		
		em.persist(mention);
		return mention;
	}

	
	public Mention updateMention(Mention mention) {
		
		return em.merge(mention);
	}

	
	
	/**
	 * ajouter un parcours a une mention
	 * @param parcours
	 * @param mention
	 */
	
	public void addParcoursToMention(Parcours parcours, Mention mention){
		
		Mention ment = em.find(Mention.class, mention.getAcronyme());
		if(ment==null){
			throw new DaoException("cette mention n'existe pas ", 2);
		}
		
		parcours.setMention(ment);
		ment.addParcours(parcours);
		em.persist(parcours);
		
	}

	/**
	 * recuperer tous les parcours d'une mention
	 * @param mention
	 * @return
	 */
	@SuppressWarnings("unchecked")
	
	public List<Parcours> findAllParcoursIntoMention(Mention mention){
		Mention ment = em.find(Mention.class, mention.getAcronyme());
		if(ment==null){
			throw new DaoException("cette mention n'existe pas encore", 2);
		}
		
		return em.createQuery("select p from Parcours p where ACRONYME = :acronyme").
		setParameter("acronyme",ment.getAcronyme()).
		getResultList();
	}

	/**
	 * ajouter un groupe de parcours a une mention
	 * @param gpparcours
	 * @param mention
	 */
	public void addGroupeParcoursToMention(GroupeParcours gpparcours, Mention mention){
		Mention mention2 = em.find(Mention.class, mention.getAcronyme());
		if(mention2== null){
			throw new DaoException("cette mention n'existe pas encore ", 2);
		}
		
		mention2.addGroupeParcours(gpparcours);
		gpparcours.setMention(mention2);
		em.persist(gpparcours);
	}
	
	/**
	 * recuperer tous les groupes de parcours d'une mention
	 * @param mention
	 * @return
	 */
	@SuppressWarnings("unchecked")
	
	public List<GroupeParcours> findAllGroupeParcoursIntoMention(Mention mention){
		Mention mention2= em.find(Mention.class, mention.getAcronyme());
		if(mention2==null){
			throw new DaoException("cette mention n'existe pas encore", 2);
		}
		
		return em.createQuery("select gp from GroupeParcours gp where MENTION = :idMention").
		setParameter("idMention", mention.getAcronyme()).getResultList();
	}

	/**
	 * recuperer le domaine d'une mention
	 * @param mention
	 * @return Mention
	 */
	
	public Domaine findDomaineOfMention(Mention mention){
		Mention mention2= em.find(Mention.class, mention.getAcronyme());
		if(mention2==null){
			throw new DaoException("cette mention n'existe pas encore", 2);
		}
		
		Integer l=mention2.getDomaine().getId();
		Domaine domaine = em.find(Domaine.class, l);
		return domaine;
		
	}
	
	

	/**
	 * ajouter un responsable a un parcours
	 * @param personne
	 * @param parcours
	 */
	
	public void addResponsableToMention(Personne personne, Mention mention){
		Mention mention2 =em.find(Mention.class, mention.getAcronyme());
		if (mention2==null){
			throw new DaoException("ce parcours n'existe pas ", 2);

		}

		Personne personne2 = em.find(Personne.class, personne.getCode());
		if(personne2==null) 
			throw new DaoException("cette personne n'existe pas ", 2);

		
		personne2.addMention(mention2);
		mention2.addResponsable(personne2);
		em.merge(mention2);
		em.merge(personne2);
	}
	
	/**
	 * 
	 * @param mention
	 * @return
	 */

	@SuppressWarnings("unchecked")
	
	public List<Personne> findAllResponsableIntoMention(Mention mention) {
		
		Mention mention2 = em.find(Mention.class, mention.getAcronyme());
		if(mention2==null)  throw new DaoException("cette mention n'existe pas", 2);

		return  em.createQuery("select p from Personne p left join p.listMentions pr where MENTION = :idD").
		setParameter("idD", mention2.getAcronyme()).getResultList();

	}

	
	
//__________________________________________________DAO SEMESTRE______________________________________________________________________

	
	
	
	
	
	public void deleteSemestre(String code) {
		
		Semestre semestre = em.find(Semestre.class, code);
		if(semestre==null){
			throw new DaoException(2);
		}
		
		em.remove(semestre);
	}

	@SuppressWarnings("unchecked")
	
	public List<Semestre> findAllSemestre() {
		
		return em.createQuery("select s from Semestre s").getResultList();
	}

	
	@SuppressWarnings("unchecked")
	
	public List<Semestre> findAllSemestreLike(String modele) {
		
		return em.createQuery("select s from Semestre s where s.libelle like :modele").
		setParameter("modele", modele).getResultList();
	}

	
	public Semestre findSemestre(String id) {
		
		return em.find(Semestre.class, id);
	}

	
	public Semestre saveSemestre(Semestre semestre) {
		
		
		em.persist(semestre);
		return semestre;
	}

	/**
	 * 
	 */
	
	public Semestre updateSemestre(Semestre semestre) {
		
		return em.merge(semestre);
	}
	
	/**
	 * permet d'obtenir le domaine d'un semestre 
	 * @param semestre
	 * @return Domaine
	 */
	
	public Domaine findDomaineOfSemestre(Semestre semestre){
		Semestre semestre2 = em.find(Semestre.class, semestre.getCode());
		if (semestre2==null) throw new DaoException("ce semestre n'existe pas ", 2);
		
		Domaine dom = em.find(Domaine.class, semestre.getDomaine().getId());
		if (dom==null) return null;
		return dom;
	}
	
	/**
	 * permet d'obtenir le parcours d'un semestre
	 * @param semestre
	 * @return Parcours
	 */
	
	public Parcours findParcoursOfSemestre(Semestre semestre){
		Semestre semestre2 = em.find(Semestre.class, semestre.getCode());
		if (semestre2==null) throw new DaoException("ce semestre n'existe pas ", 2);
		
		Parcours parcours = em.find(Parcours.class, semestre.getParcours().getAcronyme());
		if (parcours==null) return null;
		return parcours;
	}
	
	/**
	 * permet d'ajouter un groupe d'UE a un semestre
	 * @param groupeUe
	 */
	public void addGroupeUeToSemestre(GroupeUe groupeUe, Semestre semestre){
		Semestre semestre2 = em.find(Semestre.class, semestre.getCode());
		if (semestre2==null) throw new DaoException("ce semestre n'existe pas ", 2);
		
		semestre2.addGroupeUe(groupeUe);
		groupeUe.setSemestre(semestre);
		em.persist(groupeUe);
		
	}
	
	/**
	 * permet d'obtenir la liste des groupes d'ue d'un semestre
	 * @param semestre
	 * @return
	 */
	@SuppressWarnings("unchecked")
	
	public List<GroupeUe> findAllGroupeUeIntoSemestre(Semestre semestre){
		Semestre semestre2 = em.find(Semestre.class, semestre.getCode());
		if (semestre2==null) throw new DaoException("ce semestre n'existe pas ", 2);
		
		return em.createQuery("select gu from GroupeUe where CODE_SEMESTRE = :idGU").
		setParameter("idGU", semestre.getCode()).getResultList();
	}
	
	

//__________________________________________________DAO UE______________________________________________________________________

	
	public void deleteUE(String id) {
		
		UniteEnseignement ue = em.find(UniteEnseignement.class, id);
		if(ue==null){
			throw new DaoException(2);
		}
		em.remove(ue);
	}

	@SuppressWarnings("unchecked")
	
	public List<UniteEnseignement> findAllUE() {
		
		return em.createQuery("select ue from UniteEnseignement ue ").getResultList();
	}

	@SuppressWarnings("unchecked")
	
	public List<UniteEnseignement> findAllUELike(String modele) {
		
		return em.createQuery("select ue from UniteEnseignement ue where ue.libelle like :modele").
		setParameter("modele", modele).
		getResultList();
	}

	
	
	public UniteEnseignement findUE(String id) {
		
		return em.find(UniteEnseignement.class, id);
	}
	

	
	public UniteEnseignement saveUE(UniteEnseignement ue) {
		
		em.persist(ue);
		return ue;
	}

	
	public UniteEnseignement updateUE(UniteEnseignement ue) {
		
		return em.merge(ue);
	}
	
	
	/**
	 * elle permet d'ajouter un responsable a une unite d'enseignment
	 * @param personne
	 * @param uniteEnseignement
	 */
	
	
	public void addResponsableToUe(Personne personne, UniteEnseignement uniteEnseignement)
	{
		UniteEnseignement uniteEnseignement2= em.find(UniteEnseignement.class,uniteEnseignement.getCode());
		
		if(uniteEnseignement2==null ) throw new DaoException("cette UE n'existe pas ", 2);
		
		Personne personne2 = em.find(Personne.class, personne.getCode());
		
		personne2.addUniteEnseignement(uniteEnseignement2);
		uniteEnseignement2.addResponsable(personne2);
		em.merge(personne2);
		em.merge(uniteEnseignement2);
		
	}
	
	
	
	/**
	 * permet de trouver le responsable d'une unite d'enseignement
	 * @param uniteEnseignement
	 * @return Personne
	 */
	@SuppressWarnings("unchecked")
	
	public List<Personne> findResponsableOfUe(UniteEnseignement uniteEnseignement ){
		UniteEnseignement uniteEnseignement2= em.find(UniteEnseignement.class, uniteEnseignement.getCode());
		if(uniteEnseignement2==null ) throw new DaoException("cette UE n'existe pas ", 2);
		
		return em.createQuery("select p from Personne p left join p.unitesEnseignement pr where UNITE_ENSEIGNEMENT = :codeUniteEnseignement ").
		setParameter("codeUniteEnseignement", uniteEnseignement.getCode()).getResultList();
	}
	
	
	
	/**
	 * permet de trouver le domaine d'une unite d'enseignement
	 * @param uniteEnseignement
	 * @return Domaine
	 */
	
	public Domaine findDomaineOfUe(UniteEnseignement uniteEnseignement)
	{
		UniteEnseignement uniteEnseignement2 = em.find(
				UniteEnseignement.class,
				uniteEnseignement.getCode());
		
		if(uniteEnseignement2==null ) 
			throw new DaoException("cette UE n'existe pas ", 2);		
		
		Domaine domaine = em.find(Domaine.class, uniteEnseignement2.getDomaine().getId());
		return domaine;
	}
	
	/**
	 * permet d'ajouter un groupe d'UE a une unite d'enseignement
	 * @param groupeUe
	 * @param uniteEnseignement
	 */
	public void addGroupeUeToUe(GroupeUe groupeUe, UniteEnseignement uniteEnseignement){
		UniteEnseignement uniteEnseignement2= em.find(UniteEnseignement.class,uniteEnseignement.getCode());
		if(uniteEnseignement2==null ) throw new DaoException("cette UE n'existe pas ", 2);
		
		groupeUe.addUniteEnseignement(uniteEnseignement2);
		uniteEnseignement2.addGroupeUe(groupeUe);
		em.persist(groupeUe);
		
	}
	
	/**
	 * permet de trouver tous les groupes auxquels appartient une unite d'enseignement
	 * @param uniteEnseignement
	 * @return List<GroupeUe>
	 */
	
	@SuppressWarnings("unchecked")
	
	public List<GroupeUe> findAllGroupeUeIntoUe(UniteEnseignement uniteEnseignement){
		UniteEnseignement uniteEnseignement2= em.find(UniteEnseignement.class,uniteEnseignement.getCode());
		if(uniteEnseignement2==null ) throw new DaoException("cette UE n'existe pas ", 2);

		return em.createQuery("select gu from GroupeUe gu left join gu.unitesEnseignement where UNITE_ENSEIGNEMENT = :idUE").
		setParameter("idUE", uniteEnseignement.getCode()).getResultList();
	}
	
	
//__________________________________________________DAO_LIEU______________________________________________________________________
	
	/**
	 * @see IDao
	 */
	
	public void deleteLieu(Integer id) {
		
		Lieu lieu = em.find(Lieu.class, id);
		if(lieu==null){
			throw new DaoException(2);
		}
		em.persist(lieu);
	}
	
	@SuppressWarnings("unchecked")
	
	public List<Lieu> findAllLieu() {
		
		return em.createQuery("select l from Lieu l ").getResultList();
	}

	
	@SuppressWarnings("unchecked")
	
	public List<Lieu> findAllLieuLike(String modele) {
		
		return em.createQuery("select l from Lieu l ").
		setParameter("modele", modele).
		getResultList();
	}

	
	
	
	public Lieu findLieu(Integer id) {
		
		return em.find(Lieu.class, id);
	}

	
	public Lieu saveLieu(Lieu lieu) {
		
		em.persist(lieu);
		return lieu;
	}

	
	public Lieu updateLieu(Lieu lieu) {
		
		return em.merge(lieu);
	}
	
	

//__________________________________________________DAO_GROUPE-UE______________________________________________________________________

	
	public void deletegroupeUe(Integer id) {
		
		GroupeUe grpue = em.find(GroupeUe.class, id);
		if(grpue == null){
			throw new DaoException(2);
		}
		em.remove(grpue);
	}

	@SuppressWarnings("unchecked")
	
	public List<GroupeUe> findAllGroupeUe() {
		
		return em.createQuery("select g from GroupeUe g ").getResultList();
	}

	@SuppressWarnings("unchecked")
	
	public List<GroupeUe> findAllGroupeUeLike(String modele) {
		
		return em.createQuery("select g from GroupeUe g ").
		setParameter("modele", modele).getResultList();
	}

	
	public GroupeUe findGroupeUe(Integer id) {
		
		return em.find(GroupeUe.class, id);
	}

	
	public GroupeUe savegroupeUe(GroupeUe groupeUe) {
		
		em.persist(groupeUe);
		return groupeUe;
	}

	
	public GroupeUe updateGroupeUe(GroupeUe groupeUe) {
		
		return em.merge(groupeUe);
	}

	/**
	 * ajouter une unite d'enseignment a un groupe d'ue
	 * @param enseignement
	 * @param groupeUe
	 */
	
	public void addUeToGroupeUe(UniteEnseignement enseignement, GroupeUe groupeUe){
		GroupeUe groupeUe2 = em.find(GroupeUe.class, groupeUe.getId());
		if(groupeUe2 == null) throw new DaoException("cette unite d'enseignment n'existe pas ", 2);
		Domaine domaine = groupeUe2.getSemestre().getDomaine();
		enseignement.addGroupeUe(groupeUe2);
		groupeUe2.addUniteEnseignement(enseignement);
		enseignement.setDomaine(domaine);
		em.persist(enseignement);
	}

	/**
	 * permet d'avoir la liste des ue d'un groupe d'ue
	 * @param groupeUe
	 * @return L<UniteEnseignement>
	 */
	
	@SuppressWarnings("unchecked")
	public List<UniteEnseignement> findallUeOfGroupeUe(GroupeUe  groupeUe){
		GroupeUe groupeUe2 = em.find(GroupeUe.class, groupeUe.getId());
		if(groupeUe2==null) throw new DaoException("ce groupe n'existe pas ", 2);
		
		return em.createQuery("select u from UniteEnseignement u left join u.groupes ug  where GROUPEUE_ID = :idG").
		setParameter("idG", groupeUe.getId()).getResultList();

	} 
 
	 
	/**
	 * permet d'obtenir le semestre d'un groupe d'ue
	 * @param groupeUe
	 * @return Semestre
	 */
	
	public Semestre findSemestreOfGroupeUe(GroupeUe groupeUe){
		GroupeUe groupeUe2 = em.find(GroupeUe.class, groupeUe.getId());
		if(groupeUe2==null) throw new DaoException("ce groupe n'existe pas ", 2);
		
		Semestre semestre = em.find(Semestre.class, groupeUe2.getId());
		return semestre;
	}
	

//__________________________________________________DAO_GROUPE-PARCOURS______________________________________________________________________

	
	public void deleteGroupeParcours(Integer id) {
		
		GroupeParcours grp = em.find(GroupeParcours.class, id);
		if(grp == null){
			throw new DaoException(2);
		}
		em.remove(grp);
	}



	@SuppressWarnings("unchecked")
	
	public List<GroupeParcours> findAllGroupeParcours() {
		
		return em.createQuery("select gr from GroupeParcours gr").getResultList();
	}

	@SuppressWarnings("unchecked")
	
	public List<GroupeParcours> findAllGroupeParcoursLike(String modele) {
		
		return em.createQuery("select gr from GroupeParcours gr").
		setParameter("modele", modele).getResultList();
	}

	
	public GroupeParcours findGroupeParcours(Integer id) {
		
		return em.find(GroupeParcours.class, id);
	}

	
	public GroupeParcours saveGroupeParcours(GroupeParcours groupeParcours) {
		
		em.persist(groupeParcours);
		return groupeParcours;
	}

	
	public GroupeParcours updateGroupeParcours(GroupeParcours groupeParcours) {
		
		return em.merge(groupeParcours);
	}


	
	public Mention findMentionOfGroupeParcours(GroupeParcours groupeParcours) {
		
		GroupeParcours groupeParcours2=em.find(GroupeParcours.class, groupeParcours.getAcronyme());
		if(groupeParcours2 ==null) throw new DaoException("ce groupe de parcours n'existe pas encore",2);
		Mention mention =em.find(Mention.class, groupeParcours2.getAcronyme());

		return mention;
	}

	
	public void addParcoursInGroupeParcours(Parcours parcours,GroupeParcours groupeParcours) {
		
		GroupeParcours groupeParcours2 = em.find(GroupeParcours.class, groupeParcours.getAcronyme());
		if(groupeParcours2==null) throw new DaoException("ce groupe de parcours n'existe pas ",2);

		groupeParcours2.addParcours(parcours);
		parcours.setGroupeParcours(groupeParcours2);
		em.persist(parcours);


	}


	@SuppressWarnings("unchecked")
	
	public List<Parcours> findAllParcoursOfGroupeParcours(GroupeParcours groupeParcours) {
		
		GroupeParcours groupeParcours2 =em.find(GroupeParcours.class, groupeParcours.getAcronyme());
		if(groupeParcours2==null) throw new DaoException("ce groupe de parcours n'existe pas encore", 2);

		return em.createQuery("select p from Parcours p where ACRONYME_GROUPEPARCOURS = :idP").
		setParameter("idP", groupeParcours2.getAcronyme()).getResultList();
	}


	public EntityManager getEm() {
		return em;
	}

	
	public void setEm(EntityManager em) {
		this.em = em;
	}

	
	
}
